"""对话式数据探索接口

提供自然语言查询数据和解释分析结果的功能。
"""

import re
import logging
from typing import Dict, List, Any, Optional, Tuple
import pandas as pd
import numpy as np
from datetime import datetime
import requests
import json
import os

class ChatInterface:
    """对话式数据探索接口"""
    
    def __init__(self, data: Optional[pd.DataFrame] = None, analysis_results: Optional[Dict[str, Any]] = None):
        """
        初始化对话接口
        
        Args:
            data: 数据集
            analysis_results: 分析结果
        """
        self.data = data
        self.analysis_results = analysis_results or {}
        self.logger = logging.getLogger(__name__)
        
        # 查询模式映射
        self.query_patterns = {
            'basic_info': [
                r'数据.*大小|多少.*记录|多少.*行|数据.*规模',
                r'有.*变量|多少.*列|字段.*数量',
                r'数据.*概况|数据.*概述|数据.*基本信息'
            ],
            'statistics': [
                r'平均.*|均值.*|mean',
                r'最大.*|最小.*|max|min',
                r'标准差.*|方差.*|std|variance',
                r'中位数.*|median',
                r'统计.*信息|描述.*统计'
            ],
            'correlation': [
                r'相关.*|关联.*|correlation',
                r'.*之间.*关系|.*和.*关系'
            ],
            'clustering': [
                r'聚类.*|群体.*|cluster',
                r'分组.*|分类.*|group'
            ],
            'distribution': [
                r'分布.*|distribution',
                r'正态.*|偏态.*|normal|skew'
            ],
            'outliers': [
                r'异常.*|outlier',
                r'离群.*|极值.*'
            ],
            'text_analysis': [
                r'文本.*|text',
                r'情感.*|sentiment',
                r'主题.*|topic',
                r'关键词.*|keyword'
            ],
            'visualization': [
                r'图表.*|可视化.*|visualization',
                r'画.*图|绘制.*|plot|chart'
            ]
        }
        
        # 响应模板
        self.response_templates = {
            'data_not_loaded': "抱歉，当前没有加载数据。请先加载数据后再进行查询。",
            'analysis_not_done': "相关分析尚未完成。建议先进行 {analysis_type} 分析。",
            'variable_not_found': "未找到变量 '{variable}'。可用的变量包括：{available_vars}",
            'no_results': "抱歉，没有找到相关的分析结果。",
            'error': "处理查询时出现错误：{error}"
        }
    
    def update_data(self, data: pd.DataFrame):
        """更新数据集"""
        self.data = data
    
    def update_analysis_results(self, analysis_results: Dict[str, Any]):
        """更新分析结果"""
        self.analysis_results = analysis_results
    
    def query_data(self, natural_language_query: str) -> Dict[str, Any]:
        """
        自然语言查询数据
        
        Args:
            natural_language_query: 自然语言查询
            
        Returns:
            查询结果
        """
        try:
            # 预处理查询
            query = natural_language_query.lower().strip()
            
            # 识别查询类型
            query_type = self._identify_query_type(query)
            
            # 提取变量名
            variables = self._extract_variables(query)
            
            # 根据查询类型处理
            if query_type == 'basic_info':
                return self._handle_basic_info_query()
            elif query_type == 'statistics':
                return self._handle_statistics_query(variables)
            elif query_type == 'correlation':
                return self._handle_correlation_query(variables)
            elif query_type == 'clustering':
                return self._handle_clustering_query()
            elif query_type == 'distribution':
                return self._handle_distribution_query(variables)
            elif query_type == 'outliers':
                return self._handle_outliers_query(variables)
            elif query_type == 'text_analysis':
                return self._handle_text_analysis_query()
            elif query_type == 'visualization':
                return self._handle_visualization_query(variables)
            else:
                return self._handle_general_query(query)
            
        except Exception as e:
            self.logger.error(f"查询处理失败: {e}")
            return {
                'success': False,
                'response': self.response_templates['error'].format(error=str(e)),
                'query_type': 'error'
            }
    
    def _identify_query_type(self, query: str) -> str:
        """识别查询类型"""
        for query_type, patterns in self.query_patterns.items():
            for pattern in patterns:
                if re.search(pattern, query):
                    return query_type
        return 'general'
    
    def _extract_variables(self, query: str) -> List[str]:
        """从查询中提取变量名"""
        variables = []
        
        if self.data is not None:
            # 检查查询中是否包含数据列名
            for col in self.data.columns:
                if col.lower() in query:
                    variables.append(col)
        
        return variables
    
    def _handle_basic_info_query(self) -> Dict[str, Any]:
        """处理基本信息查询"""
        if self.data is None:
            return {
                'success': False,
                'response': self.response_templates['data_not_loaded'],
                'query_type': 'basic_info'
            }
        
        n_rows, n_cols = self.data.shape
        numeric_cols = len(self.data.select_dtypes(include=[np.number]).columns)
        categorical_cols = len(self.data.select_dtypes(include=['object', 'category']).columns)
        missing_percentage = (self.data.isnull().sum().sum() / (n_rows * n_cols)) * 100
        
        response = f"""数据集基本信息：
• 总记录数：{n_rows:,} 行
• 总变量数：{n_cols} 列
• 数值型变量：{numeric_cols} 个
• 分类型变量：{categorical_cols} 个
• 缺失数据比例：{missing_percentage:.2f}%
• 数据列名：{', '.join(self.data.columns.tolist())}"""
        
        return {
            'success': True,
            'response': response,
            'query_type': 'basic_info',
            'data': {
                'n_rows': n_rows,
                'n_cols': n_cols,
                'numeric_cols': numeric_cols,
                'categorical_cols': categorical_cols,
                'missing_percentage': missing_percentage,
                'columns': self.data.columns.tolist()
            }
        }
    
    def _handle_statistics_query(self, variables: List[str]) -> Dict[str, Any]:
        """处理统计信息查询"""
        if self.data is None:
            return {
                'success': False,
                'response': self.response_templates['data_not_loaded'],
                'query_type': 'statistics'
            }
        
        # 如果没有指定变量，使用所有数值型变量
        if not variables:
            variables = self.data.select_dtypes(include=[np.number]).columns.tolist()
        
        if not variables:
            return {
                'success': False,
                'response': "没有找到可用的数值型变量进行统计分析。",
                'query_type': 'statistics'
            }
        
        # 验证变量是否存在
        valid_variables = [var for var in variables if var in self.data.columns]
        if not valid_variables:
            return {
                'success': False,
                'response': self.response_templates['variable_not_found'].format(
                    variable=', '.join(variables),
                    available_vars=', '.join(self.data.columns.tolist())
                ),
                'query_type': 'statistics'
            }
        
        # 计算统计信息
        stats_data = {}
        response_parts = ["统计信息：\n"]
        
        for var in valid_variables:
            if pd.api.types.is_numeric_dtype(self.data[var]):
                var_stats = {
                    'count': self.data[var].count(),
                    'mean': self.data[var].mean(),
                    'std': self.data[var].std(),
                    'min': self.data[var].min(),
                    'max': self.data[var].max(),
                    'median': self.data[var].median()
                }
                stats_data[var] = var_stats
                
                response_parts.append(f"\n• {var}:")
                response_parts.append(f"  - 平均值: {var_stats['mean']:.3f}")
                response_parts.append(f"  - 标准差: {var_stats['std']:.3f}")
                response_parts.append(f"  - 最小值: {var_stats['min']:.3f}")
                response_parts.append(f"  - 最大值: {var_stats['max']:.3f}")
                response_parts.append(f"  - 中位数: {var_stats['median']:.3f}")
        
        return {
            'success': True,
            'response': '\n'.join(response_parts),
            'query_type': 'statistics',
            'data': stats_data
        }
    
    def _handle_correlation_query(self, variables: List[str]) -> Dict[str, Any]:
        """处理相关性查询"""
        if 'statistical_analysis' not in self.analysis_results:
            return {
                'success': False,
                'response': self.response_templates['analysis_not_done'].format(analysis_type='统计'),
                'query_type': 'correlation'
            }
        
        stats = self.analysis_results['statistical_analysis']
        if 'correlation_matrix' not in stats:
            return {
                'success': False,
                'response': "相关性分析结果不可用。",
                'query_type': 'correlation'
            }
        
        # correlation_matrix是字典格式，需要转换为DataFrame再转为numpy数组
        corr_dict = stats['correlation_matrix']
        var_names = stats.get('variables', list(corr_dict.keys()))
        
        # 将字典转换为DataFrame然后转为numpy数组
        import pandas as pd
        corr_df = pd.DataFrame(corr_dict)
        corr_matrix = corr_df.values
        
        # 如果指定了变量，只显示相关的相关性
        if len(variables) == 2 and all(var in var_names for var in variables):
            idx1 = var_names.index(variables[0])
            idx2 = var_names.index(variables[1])
            corr_value = corr_matrix[idx1][idx2]
            
            strength = "强" if abs(corr_value) > 0.7 else "中等" if abs(corr_value) > 0.3 else "弱"
            direction = "正" if corr_value > 0 else "负"
            
            response = f"{variables[0]} 和 {variables[1]} 之间存在{strength}{direction}相关关系（相关系数：{corr_value:.3f}）。"
        else:
            # 显示最强的相关关系
            strong_correlations = []
            for i in range(len(corr_matrix)):
                for j in range(i+1, len(corr_matrix)):
                    corr = corr_matrix[i][j]
                    if abs(corr) > 0.5:  # 中等以上相关性
                        strong_correlations.append((var_names[i], var_names[j], corr))
            
            if strong_correlations:
                response_parts = ["发现的主要相关关系：\n"]
                for var1, var2, corr in sorted(strong_correlations, key=lambda x: abs(x[2]), reverse=True)[:5]:
                    strength = "强" if abs(corr) > 0.7 else "中等"
                    direction = "正" if corr > 0 else "负"
                    response_parts.append(f"• {var1} 与 {var2}: {strength}{direction}相关 ({corr:.3f})")
                response = '\n'.join(response_parts)
            else:
                response = "未发现显著的相关关系（相关系数绝对值均小于0.5）。"
        
        return {
            'success': True,
            'response': response,
            'query_type': 'correlation',
            'data': {
                'correlation_matrix': corr_matrix.tolist(),
                'variables': var_names
            }
        }
    
    def _handle_clustering_query(self) -> Dict[str, Any]:
        """处理聚类查询"""
        if 'cluster_analysis' not in self.analysis_results:
            return {
                'success': False,
                'response': self.response_templates['analysis_not_done'].format(analysis_type='聚类'),
                'query_type': 'clustering'
            }
        
        cluster_results = self.analysis_results['cluster_analysis']
        
        response_parts = ["聚类分析结果：\n"]
        
        if 'n_clusters' in cluster_results:
            response_parts.append(f"• 识别出 {cluster_results['n_clusters']} 个群体")
        
        if 'silhouette_score' in cluster_results:
            silhouette = cluster_results['silhouette_score']
            quality = "优秀" if silhouette > 0.7 else "良好" if silhouette > 0.5 else "一般"
            response_parts.append(f"• 聚类质量：{quality}（轮廓系数：{silhouette:.3f}）")
        
        if 'cluster_sizes' in cluster_results:
            sizes = cluster_results['cluster_sizes']
            response_parts.append(f"• 各群体大小：{sizes}")
        
        if 'cluster_centers' in cluster_results:
            response_parts.append("• 各群体具有不同的特征模式")
        
        return {
            'success': True,
            'response': '\n'.join(response_parts),
            'query_type': 'clustering',
            'data': cluster_results
        }
    
    def _handle_distribution_query(self, variables: List[str]) -> Dict[str, Any]:
        """处理分布查询"""
        if self.data is None:
            return {
                'success': False,
                'response': self.response_templates['data_not_loaded'],
                'query_type': 'distribution'
            }
        
        # 如果没有指定变量，使用第一个数值型变量
        if not variables:
            numeric_cols = self.data.select_dtypes(include=[np.number]).columns.tolist()
            if numeric_cols:
                variables = [numeric_cols[0]]
            else:
                return {
                    'success': False,
                    'response': "没有找到可用的数值型变量进行分布分析。",
                    'query_type': 'distribution'
                }
        
        response_parts = ["分布特征：\n"]
        distribution_data = {}
        
        for var in variables:
            if var in self.data.columns and pd.api.types.is_numeric_dtype(self.data[var]):
                from scipy import stats
                
                data_series = self.data[var].dropna()
                
                # 计算分布特征
                skewness = stats.skew(data_series)
                kurtosis = stats.kurtosis(data_series)
                
                # 正态性检验
                _, p_value = stats.shapiro(data_series[:5000])  # 限制样本大小
                
                distribution_data[var] = {
                    'skewness': skewness,
                    'kurtosis': kurtosis,
                    'normality_p_value': p_value
                }
                
                response_parts.append(f"\n• {var}:")
                
                # 偏度描述
                if abs(skewness) < 0.5:
                    skew_desc = "近似对称"
                elif skewness > 0:
                    skew_desc = "右偏（正偏）"
                else:
                    skew_desc = "左偏（负偏）"
                response_parts.append(f"  - 偏度：{skew_desc} ({skewness:.3f})")
                
                # 峰度描述
                if abs(kurtosis) < 0.5:
                    kurt_desc = "正常峰度"
                elif kurtosis > 0:
                    kurt_desc = "尖峰分布"
                else:
                    kurt_desc = "平峰分布"
                response_parts.append(f"  - 峰度：{kurt_desc} ({kurtosis:.3f})")
                
                # 正态性
                is_normal = p_value > 0.05
                normal_desc = "符合正态分布" if is_normal else "不符合正态分布"
                response_parts.append(f"  - 正态性：{normal_desc} (p={p_value:.3f})")
        
        return {
            'success': True,
            'response': '\n'.join(response_parts),
            'query_type': 'distribution',
            'data': distribution_data
        }
    
    def _handle_outliers_query(self, variables: List[str]) -> Dict[str, Any]:
        """处理异常值查询"""
        if self.data is None:
            return {
                'success': False,
                'response': self.response_templates['data_not_loaded'],
                'query_type': 'outliers'
            }
        
        # 如果没有指定变量，使用所有数值型变量
        if not variables:
            variables = self.data.select_dtypes(include=[np.number]).columns.tolist()
        
        response_parts = ["异常值检测结果：\n"]
        outlier_data = {}
        
        for var in variables:
            if var in self.data.columns and pd.api.types.is_numeric_dtype(self.data[var]):
                data_series = self.data[var].dropna()
                
                # 使用IQR方法检测异常值
                Q1 = data_series.quantile(0.25)
                Q3 = data_series.quantile(0.75)
                IQR = Q3 - Q1
                lower_bound = Q1 - 1.5 * IQR
                upper_bound = Q3 + 1.5 * IQR
                
                outliers = data_series[(data_series < lower_bound) | (data_series > upper_bound)]
                outlier_count = len(outliers)
                outlier_percentage = (outlier_count / len(data_series)) * 100
                
                outlier_data[var] = {
                    'count': outlier_count,
                    'percentage': outlier_percentage,
                    'lower_bound': lower_bound,
                    'upper_bound': upper_bound
                }
                
                response_parts.append(f"\n• {var}:")
                response_parts.append(f"  - 异常值数量：{outlier_count} 个 ({outlier_percentage:.2f}%)")
                response_parts.append(f"  - 正常范围：[{lower_bound:.3f}, {upper_bound:.3f}]")
                
                if outlier_count > 0:
                    response_parts.append(f"  - 异常值范围：{outliers.min():.3f} ~ {outliers.max():.3f}")
        
        return {
            'success': True,
            'response': '\n'.join(response_parts),
            'query_type': 'outliers',
            'data': outlier_data
        }
    
    def _handle_text_analysis_query(self) -> Dict[str, Any]:
        """处理文本分析查询"""
        if 'text_analysis' not in self.analysis_results:
            return {
                'success': False,
                'response': self.response_templates['analysis_not_done'].format(analysis_type='文本'),
                'query_type': 'text_analysis'
            }
        
        text_results = self.analysis_results['text_analysis']
        response_parts = ["文本分析结果：\n"]
        
        # 情感分析结果
        if 'sentiment_analysis' in text_results:
            sentiment = text_results['sentiment_analysis']
            if 'sentiment_percentages' in sentiment:
                percentages = sentiment['sentiment_percentages']
                response_parts.append("\n• 情感分布:")
                for emotion, pct in percentages.items():
                    emotion_cn = {'positive': '正面', 'negative': '负面', 'neutral': '中性'}.get(emotion, emotion)
                    response_parts.append(f"  - {emotion_cn}: {pct:.1f}%")
        
        # 主题分析结果
        if 'topic_modeling' in text_results:
            topics = text_results['topic_modeling']
            if 'topics' in topics:
                response_parts.append("\n• 主要主题:")
                for i, topic in enumerate(topics['topics'][:3], 1):
                    top_words = ', '.join(topic['words'][:5])
                    response_parts.append(f"  - 主题{i}: {top_words}")
        
        # 关键词结果
        if 'keywords' in text_results:
            keywords = text_results['keywords']
            if keywords:
                top_keywords = [kw[0] for kw in keywords[:10]]
                response_parts.append(f"\n• 关键词: {', '.join(top_keywords)}")
        
        return {
            'success': True,
            'response': '\n'.join(response_parts),
            'query_type': 'text_analysis',
            'data': text_results
        }
    
    def _handle_visualization_query(self, variables: List[str]) -> Dict[str, Any]:
        """处理可视化查询"""
        suggestions = []
        
        if self.data is not None:
            numeric_cols = self.data.select_dtypes(include=[np.number]).columns.tolist()
            categorical_cols = self.data.select_dtypes(include=['object', 'category']).columns.tolist()
            
            if variables:
                # 针对特定变量的可视化建议
                for var in variables:
                    if var in numeric_cols:
                        suggestions.append(f"• {var}: 建议使用直方图或密度图查看分布")
                    elif var in categorical_cols:
                        suggestions.append(f"• {var}: 建议使用柱状图或饼图查看分布")
            else:
                # 通用可视化建议
                if len(numeric_cols) >= 2:
                    suggestions.append("• 相关性热力图：展示变量间关联关系")
                    suggestions.append("• 散点图矩阵：探索变量间关系")
                
                if 'cluster_analysis' in self.analysis_results:
                    suggestions.append("• 聚类散点图：展示群体分布")
                
                if categorical_cols:
                    suggestions.append("• 分类变量图：展示类别分布")
                
                if numeric_cols:
                    suggestions.append("• 分布图：展示数值变量分布特征")
        
        if not suggestions:
            suggestions = ["• 请先加载数据或完成相关分析后再进行可视化"]
        
        response = "可视化建议：\n" + '\n'.join(suggestions)
        
        return {
            'success': True,
            'response': response,
            'query_type': 'visualization',
            'data': {'suggestions': suggestions}
        }
    
    def _handle_general_query(self, query: str) -> Dict[str, Any]:
        """处理通用查询 - 与Claude AI对接"""
        # 构建数据上下文信息
        context_info = self._build_data_context()
        
        # 构建发送给Claude的提示
        claude_prompt = f"""
你是一个专业的数据分析助手。用户询问："{query}"

当前数据上下文：
{context_info}

请基于以上数据信息，用中文回答用户的问题。如果问题涉及具体的数据分析，请提供详细的解释和建议。
如果数据不足以回答问题，请说明需要什么额外信息。

回答要求：
1. 简洁明了，重点突出
2. 使用专业但易懂的语言
3. 如果涉及数值，请给出具体数据
4. 如果需要进一步分析，请给出建议
"""
        
        # 尝试调用外部AI服务，如果失败则使用本地智能响应
        try:
            ai_response = self._call_external_ai(claude_prompt)
            if ai_response:
                response = ai_response
            else:
                response = self._generate_intelligent_response(query, context_info)
        except Exception as e:
            self.logger.warning(f"外部AI调用失败，使用本地响应: {e}")
            response = self._generate_intelligent_response(query, context_info)
        
        return {
            'success': True,
            'response': response,
            'query_type': 'ai_assistant',
            'data': {
                'original_query': query,
                'context_used': context_info,
                'claude_prompt': claude_prompt
            }
        }
    
    def _build_data_context(self) -> str:
        """构建数据上下文信息"""
        context_parts = []
        
        if self.data is not None:
            n_rows, n_cols = self.data.shape
            numeric_cols = self.data.select_dtypes(include=[np.number]).columns.tolist()
            categorical_cols = self.data.select_dtypes(include=['object', 'category']).columns.tolist()
            
            context_parts.append(f"数据规模：{n_rows}行 × {n_cols}列")
            context_parts.append(f"数值型变量：{len(numeric_cols)}个 - {', '.join(numeric_cols[:5])}{'...' if len(numeric_cols) > 5 else ''}")
            context_parts.append(f"分类型变量：{len(categorical_cols)}个 - {', '.join(categorical_cols[:5])}{'...' if len(categorical_cols) > 5 else ''}")
            
            # 添加基本统计信息
            if numeric_cols:
                stats_summary = []
                for col in numeric_cols[:3]:  # 只显示前3个数值列的统计
                    mean_val = self.data[col].mean()
                    std_val = self.data[col].std()
                    stats_summary.append(f"{col}: 均值{mean_val:.2f}, 标准差{std_val:.2f}")
                context_parts.append(f"主要统计信息：{'; '.join(stats_summary)}")
        else:
            context_parts.append("当前未加载数据")
        
        # 添加已有分析结果
        if self.analysis_results:
            available_analyses = list(self.analysis_results.keys())
            context_parts.append(f"已完成的分析：{', '.join(available_analyses)}")
        
        return '\n'.join(context_parts)
    
    def _generate_intelligent_response(self, query: str, context: str) -> str:
        """生成智能响应（本地版本，未来可替换为Claude API调用）"""
        query_lower = query.lower()
        
        # 帮助类问题
        if any(word in query_lower for word in ['帮助', 'help', '功能', '能做什么', '怎么用']):
            return """我是您的AI数据分析助手，可以帮您：

🔍 **数据探索**
• 了解数据基本信息和结构
• 查看变量统计特征
• 发现数据中的模式和趋势

📊 **深度分析**
• 相关性分析和解释
• 聚类分析结果解读
• 异常值检测和处理建议

💡 **智能建议**
• 数据清洗和预处理建议
• 可视化方案推荐
• 进一步分析方向指导

您可以用自然语言提问，比如：
• "这个数据集有什么特点？"
• "哪些变量之间关系最密切？"
• "数据质量如何？有什么问题吗？"

有什么具体问题，请随时告诉我！"""
        
        # 数据质量问题
        if any(word in query_lower for word in ['质量', '问题', '缺失', '异常', '错误']):
            if self.data is not None:
                missing_info = self.data.isnull().sum()
                missing_cols = missing_info[missing_info > 0]
                
                if len(missing_cols) > 0:
                    missing_summary = []
                    for col, count in missing_cols.head().items():
                        pct = (count / len(self.data)) * 100
                        missing_summary.append(f"• {col}: {count}个缺失值 ({pct:.1f}%)")
                    
                    return f"""📋 **数据质量评估**

发现以下数据质量问题：

🔴 **缺失值情况**
{''.join(missing_summary)}

💡 **建议**
• 对于缺失率<5%的变量，可考虑删除缺失记录
• 对于缺失率5-20%的变量，建议用均值/众数填充
• 对于缺失率>20%的变量，需要谨慎处理，可能影响分析结果

需要我帮您制定具体的数据清洗方案吗？"""
                else:
                    return "✅ **数据质量良好**\n\n经检查，当前数据集没有发现缺失值，数据完整性较好。建议进行进一步的统计分析来了解数据分布特征。"
            else:
                return "请先加载数据，我才能为您评估数据质量。"
        
        # 推荐分析
        if any(word in query_lower for word in ['推荐', '建议', '下一步', '应该', '怎么分析']):
            if self.data is not None:
                numeric_cols = len(self.data.select_dtypes(include=[np.number]).columns)
                categorical_cols = len(self.data.select_dtypes(include=['object', 'category']).columns)
                
                suggestions = ["🎯 **分析建议**\n"]
                
                if numeric_cols >= 2:
                    suggestions.append("📈 **相关性分析** - 探索数值变量间的关联关系")
                
                if len(self.data) > 100 and numeric_cols >= 2:
                    suggestions.append("🎪 **聚类分析** - 发现数据中的隐藏群体")
                
                if categorical_cols > 0:
                    suggestions.append("📊 **分组分析** - 按类别变量进行对比分析")
                
                if numeric_cols > 0:
                    suggestions.append("📉 **分布分析** - 了解数值变量的分布特征")
                
                suggestions.append("\n💡 **可视化建议**")
                suggestions.append("• 相关性热力图 - 直观展示变量关系")
                suggestions.append("• 散点图矩阵 - 探索变量间模式")
                
                return "\n".join(suggestions)
            else:
                return "请先加载数据，我才能为您提供个性化的分析建议。"
        
        # 默认智能响应
        return f"""我理解您想了解："{query}"

基于当前的数据情况：
{context}

我建议您可以：
• 先进行基础的数据探索（如统计描述、分布分析）
• 根据具体需求选择合适的分析方法
• 如有特定问题，请详细描述，我会提供更精准的帮助

您还有什么具体想了解的吗？"""
    
    def _call_external_ai(self, prompt: str) -> Optional[str]:
        """调用外部AI服务（如Claude API）"""
        try:
            # 检查是否配置了AI服务
            ai_config = self._get_ai_config()
            if not ai_config:
                return None
            
            # 根据配置的服务类型调用相应的API
            service_type = ai_config.get('service_type', 'claude')
            
            if service_type == 'claude':
                return self._call_claude_api(prompt, ai_config)
            elif service_type == 'openai':
                return self._call_openai_api(prompt, ai_config)
            else:
                self.logger.warning(f"不支持的AI服务类型: {service_type}")
                return None
                
        except Exception as e:
            self.logger.error(f"外部AI调用失败: {e}")
            return None
    
    def _get_ai_config(self) -> Optional[Dict[str, Any]]:
        """获取AI服务配置"""
        try:
            # 从环境变量获取配置
            api_key = os.getenv('CLAUDE_API_KEY') or os.getenv('OPENAI_API_KEY')
            if not api_key:
                return None
            
            config = {
                'api_key': api_key,
                'service_type': 'claude' if os.getenv('CLAUDE_API_KEY') else 'openai',
                'base_url': os.getenv('AI_API_BASE_URL', 'https://api.anthropic.com'),
                'model': os.getenv('AI_MODEL', 'claude-3-sonnet-20240229'),
                'max_tokens': int(os.getenv('AI_MAX_TOKENS', '1000')),
                'timeout': int(os.getenv('AI_TIMEOUT', '30'))
            }
            
            return config
            
        except Exception as e:
            self.logger.error(f"获取AI配置失败: {e}")
            return None
    
    def _call_claude_api(self, prompt: str, config: Dict[str, Any]) -> Optional[str]:
        """调用Claude API"""
        try:
            headers = {
                'Content-Type': 'application/json',
                'x-api-key': config['api_key'],
                'anthropic-version': '2023-06-01'
            }
            
            data = {
                'model': config['model'],
                'max_tokens': config['max_tokens'],
                'messages': [
                    {
                        'role': 'user',
                        'content': prompt
                    }
                ]
            }
            
            response = requests.post(
                f"{config['base_url']}/v1/messages",
                headers=headers,
                json=data,
                timeout=config['timeout']
            )
            
            if response.status_code == 200:
                result = response.json()
                return result['content'][0]['text']
            else:
                self.logger.error(f"Claude API调用失败: {response.status_code} - {response.text}")
                return None
                
        except Exception as e:
            self.logger.error(f"Claude API调用异常: {e}")
            return None
    
    def _call_openai_api(self, prompt: str, config: Dict[str, Any]) -> Optional[str]:
        """调用OpenAI API"""
        try:
            headers = {
                'Content-Type': 'application/json',
                'Authorization': f"Bearer {config['api_key']}"
            }
            
            data = {
                'model': config.get('model', 'gpt-3.5-turbo'),
                'messages': [
                    {
                        'role': 'user',
                        'content': prompt
                    }
                ],
                'max_tokens': config['max_tokens'],
                'temperature': 0.7
            }
            
            response = requests.post(
                f"{config.get('base_url', 'https://api.openai.com')}/v1/chat/completions",
                headers=headers,
                json=data,
                timeout=config['timeout']
            )
            
            if response.status_code == 200:
                result = response.json()
                return result['choices'][0]['message']['content']
            else:
                self.logger.error(f"OpenAI API调用失败: {response.status_code} - {response.text}")
                return None
                
        except Exception as e:
            self.logger.error(f"OpenAI API调用异常: {e}")
            return None
    
    def explain_results(self, analysis_results: Dict[str, Any], focus_area: Optional[str] = None) -> Dict[str, Any]:
        """
        解释分析结果
        
        Args:
            analysis_results: 分析结果
            focus_area: 重点解释的领域
            
        Returns:
            解释结果
        """
        try:
            explanations = []
            
            # 统计分析解释
            if 'statistical_analysis' in analysis_results and (not focus_area or focus_area == 'statistics'):
                explanations.append(self._explain_statistical_results(analysis_results['statistical_analysis']))
            
            # 聚类分析解释
            if 'cluster_analysis' in analysis_results and (not focus_area or focus_area == 'clustering'):
                explanations.append(self._explain_clustering_results(analysis_results['cluster_analysis']))
            
            # 文本分析解释
            if 'text_analysis' in analysis_results and (not focus_area or focus_area == 'text'):
                explanations.append(self._explain_text_results(analysis_results['text_analysis']))
            
            if not explanations:
                return {
                    'success': False,
                    'response': "没有找到可解释的分析结果。",
                    'explanation_type': 'none'
                }
            
            response = "\n\n".join(filter(None, explanations))
            
            return {
                'success': True,
                'response': response,
                'explanation_type': focus_area or 'comprehensive',
                'timestamp': datetime.now().isoformat()
            }
            
        except Exception as e:
            self.logger.error(f"结果解释失败: {e}")
            return {
                'success': False,
                'response': f"解释分析结果时出现错误：{e}",
                'explanation_type': 'error'
            }
    
    def _explain_statistical_results(self, stats: Dict[str, Any]) -> str:
        """解释统计分析结果"""
        explanations = ["📊 统计分析结果解释："]
        
        # 相关性解释
        if 'correlation_matrix' in stats:
            explanations.append("\n🔗 相关性分析：")
            explanations.append("相关系数衡量变量间的线性关系强度，取值范围为-1到1。")
            explanations.append("• 接近1：强正相关（一个变量增加，另一个也增加）")
            explanations.append("• 接近-1：强负相关（一个变量增加，另一个减少）")
            explanations.append("• 接近0：无线性关系")
        
        # 描述性统计解释
        if 'descriptive_stats' in stats:
            explanations.append("\n📈 描述性统计：")
            explanations.append("• 平均值：数据的中心趋势")
            explanations.append("• 标准差：数据的离散程度，值越大表示数据越分散")
            explanations.append("• 偏度：分布的对称性，正值表示右偏，负值表示左偏")
            explanations.append("• 峰度：分布的尖锐程度")
        
        return '\n'.join(explanations)
    
    def _explain_clustering_results(self, cluster_results: Dict[str, Any]) -> str:
        """解释聚类分析结果"""
        explanations = ["🎯 聚类分析结果解释："]
        
        explanations.append("\n聚类分析将相似的数据点归为一组，帮助发现数据中的隐藏模式。")
        
        if 'silhouette_score' in cluster_results:
            silhouette = cluster_results['silhouette_score']
            explanations.append(f"\n📏 轮廓系数：{silhouette:.3f}")
            explanations.append("轮廓系数衡量聚类质量：")
            explanations.append("• 0.7-1.0：优秀的聚类结构")
            explanations.append("• 0.5-0.7：合理的聚类结构")
            explanations.append("• 0.25-0.5：弱聚类结构")
            explanations.append("• <0.25：无明显聚类结构")
        
        if 'n_clusters' in cluster_results:
            n_clusters = cluster_results['n_clusters']
            explanations.append(f"\n🎪 识别出 {n_clusters} 个不同的群体，每个群体具有相似的特征模式。")
        
        return '\n'.join(explanations)
    
    def _explain_text_results(self, text_results: Dict[str, Any]) -> str:
        """解释文本分析结果"""
        explanations = ["📝 文本分析结果解释："]
        
        # 情感分析解释
        if 'sentiment_analysis' in text_results:
            explanations.append("\n😊 情感分析：")
            explanations.append("通过自然语言处理技术分析文本的情感倾向：")
            explanations.append("• 正面情感：表达积极、满意的态度")
            explanations.append("• 负面情感：表达不满、批评的态度")
            explanations.append("• 中性情感：客观、中立的表达")
        
        # 主题建模解释
        if 'topic_modeling' in text_results:
            explanations.append("\n🎭 主题建模：")
            explanations.append("使用机器学习算法自动发现文本中的主要话题：")
            explanations.append("• 每个主题由一组相关词汇组成")
            explanations.append("• 帮助理解用户关注的重点领域")
            explanations.append("• 可用于内容分类和趋势分析")
        
        # 关键词解释
        if 'keywords' in text_results:
            explanations.append("\n🔑 关键词提取：")
            explanations.append("基于词频和重要性提取的核心词汇：")
            explanations.append("• 反映文本的主要内容")
            explanations.append("• 可用于快速了解文本主题")
        
        return '\n'.join(explanations)